/*!
 * # Semantic UI - Rating
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

(function($, window, document, undefined) {
  "use strict";

  window =
    typeof window != "undefined" && window.Math == Math
      ? window
      : typeof self != "undefined" && self.Math == Math
        ? self
        : Function("return this")();

  $.fn.rating = function(parameters) {
    var $allModules = $(this),
      moduleSelector = $allModules.selector || "",
      time = new Date().getTime(),
      performance = [],
      query = arguments[0],
      methodInvoked = typeof query == "string",
      queryArguments = [].slice.call(arguments, 1),
      returnedValue;
    $allModules.each(function() {
      var settings = $.isPlainObject(parameters)
          ? $.extend(true, {}, $.fn.rating.settings, parameters)
          : $.extend({}, $.fn.rating.settings),
        namespace = settings.namespace,
        className = settings.className,
        metadata = settings.metadata,
        selector = settings.selector,
        error = settings.error,
        eventNamespace = "." + namespace,
        moduleNamespace = "module-" + namespace,
        element = this,
        instance = $(this).data(moduleNamespace),
        $module = $(this),
        $icon = $module.find(selector.icon),
        initialLoad,
        module;

      module = {
        initialize: function() {
          module.verbose("Initializing rating module", settings);

          if ($icon.length === 0) {
            module.setup.layout();
          }

          if (settings.interactive) {
            module.enable();
          } else {
            module.disable();
          }
          module.set.initialLoad();
          module.set.rating(module.get.initialRating());
          module.remove.initialLoad();
          module.instantiate();
        },

        instantiate: function() {
          module.verbose("Instantiating module", settings);
          instance = module;
          $module.data(moduleNamespace, module);
        },

        destroy: function() {
          module.verbose("Destroying previous instance", instance);
          module.remove.events();
          $module.removeData(moduleNamespace);
        },

        refresh: function() {
          $icon = $module.find(selector.icon);
        },

        setup: {
          layout: function() {
            var maxRating = module.get.maxRating(),
              html = $.fn.rating.settings.templates.icon(maxRating);
            module.debug("Generating icon html dynamically");
            $module.html(html);
            module.refresh();
          }
        },

        event: {
          mouseenter: function() {
            var $activeIcon = $(this);
            $activeIcon.nextAll().removeClass(className.selected);
            $module.addClass(className.selected);
            $activeIcon
              .addClass(className.selected)
              .prevAll()
              .addClass(className.selected);
          },
          mouseleave: function() {
            $module.removeClass(className.selected);
            $icon.removeClass(className.selected);
          },
          click: function() {
            var $activeIcon = $(this),
              currentRating = module.get.rating(),
              rating = $icon.index($activeIcon) + 1,
              canClear =
                settings.clearable == "auto"
                  ? $icon.length === 1
                  : settings.clearable;
            if (canClear && currentRating == rating) {
              module.clearRating();
            } else {
              module.set.rating(rating);
            }
          }
        },

        clearRating: function() {
          module.debug("Clearing current rating");
          module.set.rating(0);
        },

        bind: {
          events: function() {
            module.verbose("Binding events");
            $module
              .on(
                "mouseenter" + eventNamespace,
                selector.icon,
                module.event.mouseenter
              )
              .on(
                "mouseleave" + eventNamespace,
                selector.icon,
                module.event.mouseleave
              )
              .on("click" + eventNamespace, selector.icon, module.event.click);
          }
        },

        remove: {
          events: function() {
            module.verbose("Removing events");
            $module.off(eventNamespace);
          },
          initialLoad: function() {
            initialLoad = false;
          }
        },

        enable: function() {
          module.debug("Setting rating to interactive mode");
          module.bind.events();
          $module.removeClass(className.disabled);
        },

        disable: function() {
          module.debug("Setting rating to read-only mode");
          module.remove.events();
          $module.addClass(className.disabled);
        },

        is: {
          initialLoad: function() {
            return initialLoad;
          }
        },

        get: {
          initialRating: function() {
            if ($module.data(metadata.rating) !== undefined) {
              $module.removeData(metadata.rating);
              return $module.data(metadata.rating);
            }
            return settings.initialRating;
          },
          maxRating: function() {
            if ($module.data(metadata.maxRating) !== undefined) {
              $module.removeData(metadata.maxRating);
              return $module.data(metadata.maxRating);
            }
            return settings.maxRating;
          },
          rating: function() {
            var currentRating = $icon.filter("." + className.active).length;
            module.verbose("Current rating retrieved", currentRating);
            return currentRating;
          }
        },

        set: {
          rating: function(rating) {
            var ratingIndex = rating - 1 >= 0 ? rating - 1 : 0,
              $activeIcon = $icon.eq(ratingIndex);
            $module.removeClass(className.selected);
            $icon.removeClass(className.selected).removeClass(className.active);
            if (rating > 0) {
              module.verbose("Setting current rating to", rating);
              $activeIcon
                .prevAll()
                .addBack()
                .addClass(className.active);
            }
            if (!module.is.initialLoad()) {
              settings.onRate.call(element, rating);
            }
          },
          initialLoad: function() {
            initialLoad = true;
          }
        },

        setting: function(name, value) {
          module.debug("Changing setting", name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          } else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            } else {
              settings[name] = value;
            }
          } else {
            return settings[name];
          }
        },
        internal: function(name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          } else if (value !== undefined) {
            module[name] = value;
          } else {
            return module[name];
          }
        },
        debug: function() {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            } else {
              module.debug = Function.prototype.bind.call(
                console.info,
                console,
                settings.name + ":"
              );
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function() {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            } else {
              module.verbose = Function.prototype.bind.call(
                console.info,
                console,
                settings.name + ":"
              );
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function() {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(
              console.error,
              console,
              settings.name + ":"
            );
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function(message) {
            var currentTime, executionTime, previousTime;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                Name: message[0],
                Arguments: [].slice.call(message, 1) || "",
                Element: element,
                "Execution Time": executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(
              module.performance.display,
              500
            );
          },
          display: function() {
            var title = settings.name + ":",
              totalTime = 0;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function(index, data) {
              totalTime += data["Execution Time"];
            });
            title += " " + totalTime + "ms";
            if (moduleSelector) {
              title += " '" + moduleSelector + "'";
            }
            if ($allModules.length > 1) {
              title += " " + "(" + $allModules.length + ")";
            }
            if (
              (console.group !== undefined || console.table !== undefined) &&
              performance.length > 0
            ) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              } else {
                $.each(performance, function(index, data) {
                  console.log(
                    data["Name"] + ": " + data["Execution Time"] + "ms"
                  );
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function(query, passedArguments, context) {
          var object = instance,
            maxDepth,
            found,
            response;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == "string" && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function(depth, value) {
              var camelCaseValue =
                depth != maxDepth
                  ? value +
                    query[depth + 1].charAt(0).toUpperCase() +
                    query[depth + 1].slice(1)
                  : query;
              if (
                $.isPlainObject(object[camelCaseValue]) &&
                depth != maxDepth
              ) {
                object = object[camelCaseValue];
              } else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              } else if ($.isPlainObject(object[value]) && depth != maxDepth) {
                object = object[value];
              } else if (object[value] !== undefined) {
                found = object[value];
                return false;
              } else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          } else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          } else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          } else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      } else {
        if (instance !== undefined) {
          instance.invoke("destroy");
        }
        module.initialize();
      }
    });

    return returnedValue !== undefined ? returnedValue : this;
  };

  $.fn.rating.settings = {
    name: "Rating",
    namespace: "rating",

    slent: false,
    debug: false,
    verbose: false,
    performance: true,

    initialRating: 0,
    interactive: true,
    maxRating: 4,
    clearable: "auto",

    fireOnInit: false,

    onRate: function(rating) {},

    error: {
      method: "The method you called is not defined",
      noMaximum:
        "No maximum rating specified. Cannot generate HTML automatically"
    },

    metadata: {
      rating: "rating",
      maxRating: "maxRating"
    },

    className: {
      active: "active",
      disabled: "disabled",
      selected: "selected",
      loading: "loading"
    },

    selector: {
      icon: ".icon"
    },

    templates: {
      icon: function(maxRating) {
        var icon = 1,
          html = "";
        while (icon <= maxRating) {
          html += '<i class="icon"></i>';
          icon++;
        }
        return html;
      }
    }
  };
})(jQuery, window, document);
